home *** CD-ROM | disk | FTP | other *** search
/ This Disc Bytes! / Power Computing - The Disc 2 - This Disc Bytes.ISO / mac / CodeWarrior 7 Lite for 68K / MacOS Support / Headers / Universal Headers / Drag.h < prev    next >
Text File  |  1995-07-06  |  17KB  |  420 lines
  1. /*
  2.      File:        Drag.h
  3.  
  4.      Contains:    Drag and Drop Interfaces.
  5.  
  6.      Version:    Technology:    Macintosh Drag and Drop 1.1
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. */
  19.  
  20. #ifndef __DRAG__
  21. #define __DRAG__
  22.  
  23.  
  24. #ifndef __APPLEEVENTS__
  25. #include <AppleEvents.h>
  26. #endif
  27. /*    #include <Errors.h>                                            */
  28. /*        #include <ConditionalMacros.h>                            */
  29. /*    #include <Types.h>                                            */
  30. /*    #include <Memory.h>                                            */
  31. /*        #include <MixedMode.h>                                    */
  32. /*    #include <OSUtils.h>                                        */
  33. /*    #include <Events.h>                                            */
  34. /*        #include <Quickdraw.h>                                    */
  35. /*            #include <QuickdrawText.h>                            */
  36. /*    #include <EPPC.h>                                            */
  37. /*        #include <AppleTalk.h>                                    */
  38. /*        #include <Files.h>                                        */
  39. /*            #include <Finder.h>                                    */
  40. /*        #include <PPCToolbox.h>                                    */
  41. /*        #include <Processes.h>                                    */
  42. /*    #include <Notification.h>                                    */
  43.  
  44. #ifndef __TEXTEDIT__
  45. #include <TextEdit.h>
  46. #endif
  47.  
  48. #ifdef __cplusplus
  49. extern "C" {
  50. #endif
  51.  
  52. #if PRAGMA_ALIGN_SUPPORTED
  53. #pragma options align=mac68k
  54. #endif
  55.  
  56. #if PRAGMA_IMPORT_SUPPORTED
  57. #pragma import on
  58. #endif
  59.  
  60.  
  61. enum {
  62. /* Flavor Flags */
  63.     flavorSenderOnly            = 0x00000001L,                    /* flavor is available to sender only */
  64.     flavorSenderTranslated        = 0x00000002L,                    /* flavor is translated by sender */
  65.     flavorNotSaved                = 0x00000004L,                    /* flavor should not be saved */
  66.     flavorSystemTranslated        = 0x00000100L                    /* flavor is translated by system */
  67. };
  68.  
  69. typedef unsigned long FlavorFlags;
  70.  
  71.  
  72. enum {
  73. /* Drag Attributes */
  74.     dragHasLeftSenderWindow        = 0x00000001L,                    /* drag has left the source window since TrackDrag */
  75.     dragInsideSenderApplication    = 0x00000002L,                    /* drag is occurring within the sender application */
  76.     dragInsideSenderWindow        = 0x00000004L                    /* drag is occurring within the sender window */
  77. };
  78.  
  79. typedef unsigned long DragAttributes;
  80.  
  81.  
  82. enum {
  83. /* Special Flavor Types */
  84.     flavorTypeHFS                = 'hfs ',                        /* flavor type for HFS data */
  85.     flavorTypePromiseHFS        = 'phfs',                        /* flavor type for promised HFS data */
  86.     flavorTypeDirectory            = 'diry'
  87. };
  88.  
  89. enum {
  90. /* Drag Tracking Handler Messages */
  91.     dragTrackingEnterHandler    = 1,                            /* drag has entered handler */
  92.     dragTrackingEnterWindow        = 2,                            /* drag has entered window */
  93.     dragTrackingInWindow        = 3,                            /* drag is moving within window */
  94.     dragTrackingLeaveWindow        = 4,                            /* drag has exited window */
  95.     dragTrackingLeaveHandler    = 5                                /* drag has exited handler */
  96. };
  97.  
  98. typedef short DragTrackingMessage;
  99.  
  100.  
  101. enum {
  102. /* Drag Drawing Procedure Messages */
  103.     dragRegionBegin                = 1,                            /* initialize drawing */
  104.     dragRegionDraw                = 2,                            /* draw drag feedback */
  105.     dragRegionHide                = 3,                            /* hide drag feedback */
  106.     dragRegionIdle                = 4,                            /* drag feedback idle time */
  107.     dragRegionEnd                = 5                                /* end of drawing */
  108. };
  109.  
  110. typedef short DragRegionMessage;
  111.  
  112.  
  113. enum {
  114. /* Zoom Acceleration */
  115.     zoomNoAcceleration            = 0,                            /* use linear interpolation */
  116.     zoomAccelerate                = 1,                            /* ramp up step size */
  117.     zoomDecelerate                = 2                                /* ramp down step size */
  118. };
  119.  
  120. typedef short ZoomAcceleration;
  121.  
  122. /* Drag Manager Data Types */
  123. typedef unsigned long DragReference;
  124.  
  125. typedef unsigned long ItemReference;
  126.  
  127. typedef ResType FlavorType;
  128.  
  129. /* HFS Flavors */
  130. struct HFSFlavor {
  131.     OSType                            fileType;                    /* file type */
  132.     OSType                            fileCreator;                /* file creator */
  133.     unsigned short                    fdFlags;                    /* Finder flags */
  134.     FSSpec                            fileSpec;                    /* file system specification */
  135. };
  136. typedef struct HFSFlavor HFSFlavor;
  137.  
  138. struct PromiseHFSFlavor {
  139.     OSType                            fileType;                    /* file type */
  140.     OSType                            fileCreator;                /* file creator */
  141.     unsigned short                    fdFlags;                    /* Finder flags */
  142.     FlavorType                        promisedFlavor;                /* promised flavor containing an FSSpec */
  143. };
  144. typedef struct PromiseHFSFlavor PromiseHFSFlavor;
  145.  
  146. /* Application-Defined Drag Handler Routines */
  147. typedef pascal OSErr (*DragTrackingHandlerProcPtr)(DragTrackingMessage message, WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  148.  
  149. #if GENERATINGCFM
  150. typedef UniversalProcPtr DragTrackingHandlerUPP;
  151. #else
  152. typedef DragTrackingHandlerProcPtr DragTrackingHandlerUPP;
  153. #endif
  154.  
  155. enum {
  156.     uppDragTrackingHandlerProcInfo = kPascalStackBased
  157.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  158.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragTrackingMessage)))
  159.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(WindowPtr)))
  160.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  161.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  162. };
  163.  
  164. #if GENERATINGCFM
  165. #define NewDragTrackingHandlerProc(userRoutine)        \
  166.         (DragTrackingHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, GetCurrentArchitecture())
  167. #else
  168. #define NewDragTrackingHandlerProc(userRoutine)        \
  169.         ((DragTrackingHandlerUPP) (userRoutine))
  170. #endif
  171.  
  172. #if GENERATINGCFM
  173. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  174.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, (message), (theWindow), (handlerRefCon), (theDragRef))
  175. #else
  176. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  177.         (*(userRoutine))((message), (theWindow), (handlerRefCon), (theDragRef))
  178. #endif
  179.  
  180. typedef DragTrackingHandlerUPP DragTrackingHandler;
  181.  
  182. typedef pascal OSErr (*DragReceiveHandlerProcPtr)(WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  183.  
  184. #if GENERATINGCFM
  185. typedef UniversalProcPtr DragReceiveHandlerUPP;
  186. #else
  187. typedef DragReceiveHandlerProcPtr DragReceiveHandlerUPP;
  188. #endif
  189.  
  190. enum {
  191.     uppDragReceiveHandlerProcInfo = kPascalStackBased
  192.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  193.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  194.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  195.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DragReference)))
  196. };
  197.  
  198. #if GENERATINGCFM
  199. #define NewDragReceiveHandlerProc(userRoutine)        \
  200.         (DragReceiveHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, GetCurrentArchitecture())
  201. #else
  202. #define NewDragReceiveHandlerProc(userRoutine)        \
  203.         ((DragReceiveHandlerUPP) (userRoutine))
  204. #endif
  205.  
  206. #if GENERATINGCFM
  207. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  208.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, (theWindow), (handlerRefCon), (theDragRef))
  209. #else
  210. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  211.         (*(userRoutine))((theWindow), (handlerRefCon), (theDragRef))
  212. #endif
  213.  
  214. typedef DragReceiveHandlerUPP DragReceiveHandler;
  215.  
  216. /* Application-Defined Routines */
  217. typedef pascal OSErr (*DragSendDataProcPtr)(FlavorType theType, void *dragSendRefCon, ItemReference theItemRef, DragReference theDragRef);
  218.  
  219. #if GENERATINGCFM
  220. typedef UniversalProcPtr DragSendDataUPP;
  221. #else
  222. typedef DragSendDataProcPtr DragSendDataUPP;
  223. #endif
  224.  
  225. enum {
  226.     uppDragSendDataProcInfo = kPascalStackBased
  227.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  228.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FlavorType)))
  229.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  230.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ItemReference)))
  231.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  232. };
  233.  
  234. #if GENERATINGCFM
  235. #define NewDragSendDataProc(userRoutine)        \
  236.         (DragSendDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragSendDataProcInfo, GetCurrentArchitecture())
  237. #else
  238. #define NewDragSendDataProc(userRoutine)        \
  239.         ((DragSendDataUPP) (userRoutine))
  240. #endif
  241.  
  242. #if GENERATINGCFM
  243. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  244.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragSendDataProcInfo, (theType), (dragSendRefCon), (theItemRef), (theDragRef))
  245. #else
  246. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  247.         (*(userRoutine))((theType), (dragSendRefCon), (theItemRef), (theDragRef))
  248. #endif
  249.  
  250. typedef DragSendDataUPP DragSendDataProc;
  251.  
  252. typedef pascal OSErr (*DragInputProcPtr)(Point *mouse, short *modifiers, void *dragInputRefCon, DragReference theDragRef);
  253.  
  254. #if GENERATINGCFM
  255. typedef UniversalProcPtr DragInputUPP;
  256. #else
  257. typedef DragInputProcPtr DragInputUPP;
  258. #endif
  259.  
  260. enum {
  261.     uppDragInputProcInfo = kPascalStackBased
  262.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  263.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Point*)))
  264.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short*)))
  265.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  266.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  267. };
  268.  
  269. #if GENERATINGCFM
  270. #define NewDragInputProc(userRoutine)        \
  271.         (DragInputUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture())
  272. #else
  273. #define NewDragInputProc(userRoutine)        \
  274.         ((DragInputUPP) (userRoutine))
  275. #endif
  276.  
  277. #if GENERATINGCFM
  278. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  279.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragInputProcInfo, (mouse), (modifiers), (dragInputRefCon), (theDragRef))
  280. #else
  281. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  282.         (*(userRoutine))((mouse), (modifiers), (dragInputRefCon), (theDragRef))
  283. #endif
  284.  
  285. typedef DragInputUPP DragInputProc;
  286.  
  287. typedef pascal OSErr (*DragDrawingProcPtr)(DragRegionMessage message, RgnHandle showRegion, Point showOrigin, RgnHandle hideRegion, Point hideOrigin, void *dragDrawingRefCon, DragReference theDragRef);
  288.  
  289. #if GENERATINGCFM
  290. typedef UniversalProcPtr DragDrawingUPP;
  291. #else
  292. typedef DragDrawingProcPtr DragDrawingUPP;
  293. #endif
  294.  
  295. enum {
  296.     uppDragDrawingProcInfo = kPascalStackBased
  297.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  298.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragRegionMessage)))
  299.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RgnHandle)))
  300.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Point)))
  301.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RgnHandle)))
  302.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Point)))
  303.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(void*)))
  304.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DragReference)))
  305. };
  306.  
  307. #if GENERATINGCFM
  308. #define NewDragDrawingProc(userRoutine)        \
  309.         (DragDrawingUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragDrawingProcInfo, GetCurrentArchitecture())
  310. #else
  311. #define NewDragDrawingProc(userRoutine)        \
  312.         ((DragDrawingUPP) (userRoutine))
  313. #endif
  314.  
  315. #if GENERATINGCFM
  316. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  317.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragDrawingProcInfo, (message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  318. #else
  319. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  320.         (*(userRoutine))((message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  321. #endif
  322.  
  323. typedef DragDrawingUPP DragDrawingProc;
  324.  
  325. /* Drag Manager Routines */
  326. /* Installing and Removing Drag Handlers */
  327. extern pascal OSErr InstallTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow, void *handlerRefCon)
  328.  TWOWORDINLINE(0x7001, 0xABED);
  329. extern pascal OSErr InstallReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow, void *handlerRefCon)
  330.  TWOWORDINLINE(0x7002, 0xABED);
  331. extern pascal OSErr RemoveTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow)
  332.  TWOWORDINLINE(0x7003, 0xABED);
  333. extern pascal OSErr RemoveReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow)
  334.  TWOWORDINLINE(0x7004, 0xABED);
  335. /* Creating and Disposing Drag References */
  336. extern pascal OSErr NewDrag(DragReference *theDragRef)
  337.  TWOWORDINLINE(0x7005, 0xABED);
  338. extern pascal OSErr DisposeDrag(DragReference theDragRef)
  339.  TWOWORDINLINE(0x7006, 0xABED);
  340. /* Adding Drag Item Flavors */
  341. extern pascal OSErr AddDragItemFlavor(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size dataSize, FlavorFlags theFlags)
  342.  TWOWORDINLINE(0x7007, 0xABED);
  343. extern pascal OSErr SetDragItemFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, const void *dataPtr, Size dataSize, unsigned long dataOffset)
  344.  TWOWORDINLINE(0x7009, 0xABED);
  345. /* Providing Drag Callback Procedures */
  346. extern pascal OSErr SetDragSendProc(DragReference theDragRef, DragSendDataProc sendProc, void *dragSendRefCon)
  347.  TWOWORDINLINE(0x700A, 0xABED);
  348. extern pascal OSErr SetDragInputProc(DragReference theDragRef, DragInputProc inputProc, void *dragInputRefCon)
  349.  TWOWORDINLINE(0x700B, 0xABED);
  350. extern pascal OSErr SetDragDrawingProc(DragReference theDragRef, DragDrawingProc drawingProc, void *dragDrawingRefCon)
  351.  TWOWORDINLINE(0x700C, 0xABED);
  352. extern pascal OSErr TrackDrag(DragReference theDragRef, const EventRecord *theEvent, RgnHandle theRegion)
  353.  TWOWORDINLINE(0x700D, 0xABED);
  354. /* Getting Drag Item Information */
  355. extern pascal OSErr CountDragItems(DragReference theDragRef, unsigned short *numItems)
  356.  TWOWORDINLINE(0x700E, 0xABED);
  357. extern pascal OSErr GetDragItemReferenceNumber(DragReference theDragRef, unsigned short index, ItemReference *theItemRef)
  358.  TWOWORDINLINE(0x700F, 0xABED);
  359. extern pascal OSErr CountDragItemFlavors(DragReference theDragRef, ItemReference theItemRef, unsigned short *numFlavors)
  360.  TWOWORDINLINE(0x7010, 0xABED);
  361. extern pascal OSErr GetFlavorType(DragReference theDragRef, ItemReference theItemRef, unsigned short index, FlavorType *theType)
  362.  TWOWORDINLINE(0x7011, 0xABED);
  363. extern pascal OSErr GetFlavorFlags(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, FlavorFlags *theFlags)
  364.  TWOWORDINLINE(0x7012, 0xABED);
  365. extern pascal OSErr GetFlavorDataSize(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, Size *dataSize)
  366.  TWOWORDINLINE(0x7013, 0xABED);
  367. extern pascal OSErr GetFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size *dataSize, unsigned long dataOffset)
  368.  TWOWORDINLINE(0x7014, 0xABED);
  369. extern pascal OSErr GetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, Rect *itemBounds)
  370.  TWOWORDINLINE(0x7015, 0xABED);
  371. extern pascal OSErr SetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, const Rect *itemBounds)
  372.  TWOWORDINLINE(0x7016, 0xABED);
  373. extern pascal OSErr GetDropLocation(DragReference theDragRef, AEDesc *dropLocation)
  374.  TWOWORDINLINE(0x7017, 0xABED);
  375. extern pascal OSErr SetDropLocation(DragReference theDragRef, const AEDesc *dropLocation)
  376.  TWOWORDINLINE(0x7018, 0xABED);
  377. /* Getting Information About a Drag */
  378. extern pascal OSErr GetDragAttributes(DragReference theDragRef, DragAttributes *flags)
  379.  TWOWORDINLINE(0x7019, 0xABED);
  380. extern pascal OSErr GetDragMouse(DragReference theDragRef, Point *mouse, Point *pinnedMouse)
  381.  TWOWORDINLINE(0x701A, 0xABED);
  382. extern pascal OSErr SetDragMouse(DragReference theDragRef, Point pinnedMouse)
  383.  TWOWORDINLINE(0x701B, 0xABED);
  384. extern pascal OSErr GetDragOrigin(DragReference theDragRef, Point *initialMouse)
  385.  TWOWORDINLINE(0x701C, 0xABED);
  386. extern pascal OSErr GetDragModifiers(DragReference theDragRef, short *modifiers, short *mouseDownModifiers, short *mouseUpModifiers)
  387.  TWOWORDINLINE(0x701D, 0xABED);
  388. /* Drag Highlighting */
  389. extern pascal OSErr ShowDragHilite(DragReference theDragRef, RgnHandle hiliteFrame, Boolean inside)
  390.  TWOWORDINLINE(0x701E, 0xABED);
  391. extern pascal OSErr HideDragHilite(DragReference theDragRef)
  392.  TWOWORDINLINE(0x701F, 0xABED);
  393. extern pascal OSErr DragPreScroll(DragReference theDragRef, short dH, short dV)
  394.  TWOWORDINLINE(0x7020, 0xABED);
  395. extern pascal OSErr DragPostScroll(DragReference theDragRef)
  396.  TWOWORDINLINE(0x7021, 0xABED);
  397. extern pascal OSErr UpdateDragHilite(DragReference theDragRef, RgnHandle updateRgn)
  398.  TWOWORDINLINE(0x7022, 0xABED);
  399. /* Drag Manager Utilities */
  400. extern pascal Boolean WaitMouseMoved(Point initialMouse)
  401.  TWOWORDINLINE(0x7023, 0xABED);
  402. extern pascal OSErr ZoomRects(const Rect *fromRect, const Rect *toRect, short zoomSteps, ZoomAcceleration acceleration)
  403.  TWOWORDINLINE(0x7024, 0xABED);
  404. extern pascal OSErr ZoomRegion(RgnHandle region, Point zoomDistance, short zoomSteps, ZoomAcceleration acceleration)
  405.  TWOWORDINLINE(0x7025, 0xABED);
  406.  
  407. #if PRAGMA_IMPORT_SUPPORTED
  408. #pragma import off
  409. #endif
  410.  
  411. #if PRAGMA_ALIGN_SUPPORTED
  412. #pragma options align=reset
  413. #endif
  414.  
  415. #ifdef __cplusplus
  416. }
  417. #endif
  418.  
  419. #endif /* __DRAG__ */
  420.